home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 1995 #5 & #6 / Amiga Plus CD - 1995 - No. 5 and 6.iso / pd / netz / term / extras / source / term-source.lha / termCapture.c < prev    next >
C/C++ Source or Header  |  1995-06-17  |  9KB  |  515 lines
  1. /*
  2. **    termCapture.c
  3. **
  4. **    File and printer capture support routines
  5. **
  6. **    Copyright © 1990-1995 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #include "termGlobal.h"
  11.  
  12. STATIC VOID __regargs
  13. CaptureCallback1(register APTR Buffer,register LONG Size)
  14. {
  15.     AddLine(Buffer,Size);
  16.  
  17.     CaptureToFile(Buffer,Size);
  18.     CaptureToFile("\n",1);
  19. }
  20.  
  21. STATIC VOID __regargs
  22. CaptureCallback3(register APTR Buffer,register LONG Size)
  23. {
  24.     AddLine(Buffer,Size);
  25.  
  26.     CaptureToFile(Buffer,Size);
  27.     CaptureToFile("\n",1);
  28.  
  29.     CaptureToPrinter(Buffer,Size);
  30.     CaptureToPrinter("\n",1);
  31. }
  32.  
  33. STATIC VOID __regargs
  34. CaptureCallback4(register APTR Buffer,register LONG Size)
  35. {
  36.     CaptureToFile(Buffer,Size);
  37.     CaptureToFile("\n",1);
  38. }
  39.  
  40. STATIC VOID __regargs
  41. CaptureCallback5(register APTR Buffer,register LONG Size)
  42. {
  43.     CaptureToFile(Buffer,Size);
  44.     CaptureToFile("\n",1);
  45.  
  46.     CaptureToPrinter(Buffer,Size);
  47.     CaptureToPrinter("\n",1);
  48. }
  49.  
  50. STATIC VOID __regargs
  51. CaptureCallback6(register APTR Buffer,register LONG Size)
  52. {
  53.     CaptureToPrinter(Buffer,Size);
  54.     CaptureToPrinter("\n",1);
  55. }
  56.  
  57. STATIC VOID __regargs
  58. CaptureCallback7(register APTR Buffer,register LONG Size)
  59. {
  60.     AddLine(Buffer,Size);
  61.  
  62.     CaptureToPrinter(Buffer,Size);
  63.     CaptureToPrinter("\n",1);
  64. }
  65.  
  66. VOID __regargs
  67. CaptureFilteredTo_Buffer(register APTR Buffer,register LONG Size)
  68. {
  69.     CaptureParser(Buffer,Size,AddLine);
  70. }
  71.  
  72. VOID __regargs
  73. CaptureFilteredTo_Buffer_File(register APTR Buffer,register LONG Size)
  74. {
  75.     CaptureParser(Buffer,Size,CaptureCallback1);
  76. }
  77.  
  78. VOID __regargs
  79. CaptureFilteredTo_Buffer_File_Printer(register APTR Buffer,register LONG Size)
  80. {
  81.     CaptureParser(Buffer,Size,CaptureCallback3);
  82. }
  83.  
  84. VOID __regargs
  85. CaptureFilteredTo_File(register APTR Buffer,register LONG Size)
  86. {
  87.     CaptureParser(Buffer,Size,CaptureCallback4);
  88. }
  89.  
  90. VOID __regargs
  91. CaptureFilteredTo_File_Printer(register APTR Buffer,register LONG Size)
  92. {
  93.     CaptureParser(Buffer,Size,CaptureCallback5);
  94. }
  95.  
  96. VOID __regargs
  97. CaptureFilteredTo_Printer(register APTR Buffer,register LONG Size)
  98. {
  99.     CaptureParser(Buffer,Size,CaptureCallback6);
  100. }
  101.  
  102. VOID __regargs
  103. CaptureFilteredTo_Buffer_Printer(register APTR Buffer,register LONG Size)
  104. {
  105.     CaptureParser(Buffer,Size,CaptureCallback7);
  106. }
  107.  
  108. VOID __regargs
  109. CaptureRawTo_Buffer(register APTR Buffer,register LONG Size)
  110. {
  111.     CaptureParser(Buffer,Size,AddLine);
  112. }
  113.  
  114. VOID __regargs
  115. CaptureRawTo_Buffer_File(register APTR Buffer,register LONG Size)
  116. {
  117.     CaptureParser(Buffer,Size,AddLine);
  118.  
  119.     CaptureToFile(Buffer,Size);
  120. }
  121.  
  122. VOID __regargs
  123. CaptureRawTo_Buffer_File_Printer(register APTR Buffer,register LONG Size)
  124. {
  125.     CaptureParser(Buffer,Size,AddLine);
  126.  
  127.     CaptureToFile(Buffer,Size);
  128.     CaptureToPrinter(Buffer,Size);
  129. }
  130.  
  131. VOID __regargs
  132. CaptureRawTo_Buffer_Printer(register APTR Buffer,register LONG Size)
  133. {
  134.     CaptureParser(Buffer,Size,AddLine);
  135.  
  136.     CaptureToPrinter(Buffer,Size);
  137. }
  138.  
  139. VOID __regargs
  140. CaptureRawTo_File(register APTR Buffer,register LONG Size)
  141. {
  142.     CaptureToFile(Buffer,Size);
  143. }
  144.  
  145. VOID __regargs
  146. CaptureRawTo_File_Printer(register APTR Buffer,register LONG Size)
  147. {
  148.     CaptureToFile(Buffer,Size);
  149.     CaptureToPrinter(Buffer,Size);
  150. }
  151.  
  152. VOID __regargs
  153. CaptureRawTo_Printer(register APTR Buffer,register LONG Size)
  154. {
  155.     CaptureToPrinter(Buffer,Size);
  156. }
  157.  
  158.     /* ClosePrinterCapture(BYTE Force):
  159.      *
  160.      *    Closes printer capture file.
  161.      */
  162.  
  163. VOID __regargs
  164. ClosePrinterCapture(BYTE Force)
  165. {
  166.     if(PrinterCapture)
  167.     {
  168.         if(ControllerActive && StandardPrinterCapture && !Force)
  169.             FPrintf(PrinterCapture,LocaleString(MSG_CONSOLE_TERMINAL_TRANSCRIPT_ENDING_TXT));
  170.  
  171.         if(Force)
  172.         {
  173.             Close(PrinterCapture);
  174.  
  175.             CheckItem(MEN_CAPTURE_TO_PRINTER,FALSE);
  176.  
  177.             PrinterCapture = NULL;
  178.  
  179.             ConOutputUpdate();
  180.  
  181.             StandardPrinterCapture = FALSE;
  182.         }
  183.     }
  184.  
  185.     ControllerActive = FALSE;
  186.  
  187.     ConOutputUpdate();
  188. }
  189.  
  190.     /* OpenPrinterCapture(BYTE Controller):
  191.      *
  192.      *    Opens printer capture file.
  193.      */
  194.  
  195. BYTE __regargs
  196. OpenPrinterCapture(BYTE Controller)
  197. {
  198.     if(PrinterCapture)
  199.     {
  200.         if(Controller && !ControllerActive)
  201.         {
  202.             ControllerActive = TRUE;
  203.  
  204.             ConOutputUpdate();
  205.  
  206.             FPrintf(PrinterCapture,LocaleString(MSG_CONSOLE_TERMINAL_TRANSCRIPT_FOLLOWS_TXT));
  207.         }
  208.  
  209.         return(TRUE);
  210.     }
  211.     else
  212.     {
  213.         if(PrinterCapture = Open("PRT:",MODE_NEWFILE))
  214.             CheckItem(MEN_CAPTURE_TO_PRINTER,TRUE);
  215.         else
  216.         {
  217.             CheckItem(MEN_CAPTURE_TO_PRINTER,FALSE);
  218.  
  219.             BlockWindows();
  220.  
  221.             MyEasyRequest(Window,LocaleString(MSG_TERMMAIN_ERROR_OPENING_PRINTER_TXT),LocaleString(MSG_GLOBAL_CONTINUE_TXT),"PRT:");
  222.  
  223.             ReleaseWindows();
  224.         }
  225.  
  226.         if(Controller)
  227.         {
  228.             ControllerActive    = TRUE;
  229.             StandardPrinterCapture    = FALSE;
  230.         }
  231.         else
  232.         {
  233.             StandardPrinterCapture = FALSE;
  234.  
  235.             if(ControllerActive)
  236.                 FPrintf(PrinterCapture,LocaleString(MSG_CONSOLE_USER_TERMINAL_TRANSCRIPT_FOLLOWS_TXT));
  237.         }
  238.  
  239.         ConOutputUpdate();
  240.  
  241.         if(PrinterCapture)
  242.             return(TRUE);
  243.         else
  244.             return(FALSE);
  245.     }
  246. }
  247.  
  248.     /* CloseFileCapture():
  249.      *
  250.      *    Close the capture file.
  251.      */
  252.  
  253. VOID
  254. CloseFileCapture()
  255. {
  256.     if(FileCapture)
  257.     {
  258.         BufferClose(FileCapture);
  259.  
  260.         FileCapture = NULL;
  261.  
  262.         if(!GetFileSize(CaptureName))
  263.             DeleteFile(CaptureName);
  264.         else
  265.         {
  266.             AddProtection(CaptureName,FIBF_EXECUTE);
  267.  
  268.             if(Config -> MiscConfig -> CreateIcons)
  269.                 AddIcon(CaptureName,FILETYPE_TEXT,FALSE);
  270.         }
  271.     }
  272.  
  273.     CheckItem(MEN_CAPTURE_TO_FILE,FALSE);
  274.  
  275.     ConOutputUpdate();
  276. }
  277.  
  278.     /* OpenFileCapture():
  279.      *
  280.      *    Open a capture file.
  281.      */
  282.  
  283. BYTE
  284. OpenFileCapture()
  285. {
  286.     struct FileRequester    *FileRequest;
  287.     UBYTE             DummyBuffer[MAX_FILENAME_LENGTH],
  288.                 *DummyChar;
  289.     BYTE             Aborted = FALSE;
  290.  
  291.     CloseFileCapture();
  292.  
  293.     BlockWindows();
  294.  
  295.     if(!CaptureName[0])
  296.     {
  297.         strcpy(CaptureName,Config -> CaptureConfig -> CapturePath);
  298.  
  299.         if(!AddPart(CaptureName,LocaleString(MSG_DIALPANEL_CAPTURE_NAME_TXT),MAX_FILENAME_LENGTH))
  300.             CaptureName[0] = 0;
  301.     }
  302.  
  303.     strcpy(DummyBuffer,CaptureName);
  304.  
  305.     DummyChar = PathPart(DummyBuffer);
  306.  
  307.     *DummyChar = 0;
  308.  
  309.     if(FileRequest = GetFile(Window,LocaleString(MSG_TERMMAIN_CAPTURE_TO_DISK_TXT),DummyBuffer,FilePart(CaptureName),DummyBuffer,NULL,TRUE,FALSE,FALSE,LocaleString(MSG_GLOBAL_OPEN_TXT),FALSE))
  310.     {
  311.         if(GetFileSize(DummyBuffer))
  312.         {
  313.             switch(MyEasyRequest(Window,LocaleString(MSG_GLOBAL_FILE_ALREADY_EXISTS_TXT),LocaleString(MSG_GLOBAL_CREATE_APPEND_CANCEL_TXT),DummyBuffer))
  314.             {
  315.                 case 1:
  316.  
  317.                     FileCapture = BufferOpen(DummyBuffer,"w");
  318.                     break;
  319.  
  320.                 case 2:
  321.  
  322.                     FileCapture = BufferOpen(DummyBuffer,"a");
  323.                     break;
  324.  
  325.                 case 0:
  326.  
  327.                     FileCapture = NULL;
  328.  
  329.                     Aborted = TRUE;
  330.  
  331.                     break;
  332.             }
  333.         }
  334.         else
  335.             FileCapture = BufferOpen(DummyBuffer,"w");
  336.  
  337.         if(!Aborted)
  338.         {
  339.             if(!FileCapture)
  340.                 ShowError(Window,ERR_SAVE_ERROR,IoErr(),DummyBuffer);
  341.             else
  342.                 strcpy(CaptureName,DummyBuffer);
  343.         }
  344.  
  345.         FreeAslRequest(FileRequest);
  346.     }
  347.  
  348.     if(FileCapture)
  349.         CheckItem(MEN_CAPTURE_TO_FILE,TRUE);
  350.     else
  351.         CheckItem(MEN_CAPTURE_TO_FILE,FALSE);
  352.  
  353.     ConOutputUpdate();
  354.  
  355.     ReleaseWindows();
  356.  
  357.     if(FileCapture)
  358.         return(TRUE);
  359.     else
  360.         return(FALSE);
  361. }
  362.  
  363.     /* CaptureToFile(APTR Buffer,LONG Size):
  364.      *
  365.      *    Send data to the capture file.
  366.      */
  367.  
  368. VOID __regargs
  369. CaptureToFile(APTR Buffer,LONG Size)
  370. {
  371.     if(Size)
  372.     {
  373.         if(BufferWrite(FileCapture,Buffer,Size) != Size)
  374.         {
  375.             BlockWindows();
  376.  
  377.                 /* We had an error writing to the file. */
  378.  
  379.             switch(MyEasyRequest(NULL,LocaleString(MSG_CONSOLE_ERROR_WRITING_TO_CAPTURE_FILE_TXT),LocaleString(MSG_CONSOLE_IGNORE_DISCARD_CLOSE_TXT),CaptureName))
  380.             {
  381.                 case 1:
  382.  
  383.                     BufferClose(FileCapture);
  384.  
  385.                     DeleteFile(CaptureName);
  386.  
  387.                     CheckItem(MEN_CAPTURE_TO_FILE,FALSE);
  388.  
  389.                     FileCapture = NULL;
  390.  
  391.                     ConOutputUpdate();
  392.  
  393.                     break;
  394.  
  395.                 case 2:
  396.  
  397.                     BufferClose(FileCapture);
  398.  
  399.                     CheckItem(MEN_CAPTURE_TO_FILE,FALSE);
  400.  
  401.                     FileCapture = NULL;
  402.  
  403.                     if(!GetFileSize(CaptureName))
  404.                         DeleteFile(CaptureName);
  405.                     else
  406.                     {
  407.                         AddProtection(CaptureName,FIBF_EXECUTE);
  408.  
  409.                         if(Config -> MiscConfig -> CreateIcons)
  410.                             AddIcon(CaptureName,FILETYPE_TEXT,FALSE);
  411.                     }
  412.  
  413.                     ConOutputUpdate();
  414.  
  415.                     break;
  416.             }
  417.  
  418.             ReleaseWindows();
  419.         }
  420.     }
  421. }
  422.  
  423.     /* CaptureToPrinter(APTR Buffer,LONG Size):
  424.      *
  425.      *    Send capture data to the printer, convert the
  426.      *    characters as necessary to avoid shocking the
  427.      *    printer.
  428.      */
  429.  
  430. VOID __regargs
  431. CaptureToPrinter(APTR Buffer,LONG Size)
  432. {
  433.     if(!Config -> CaptureConfig -> ConvertChars && Config -> TerminalConfig -> FontMode != FONT_STANDARD)
  434.     {
  435.         UBYTE     LocalBuffer[BUFFER_LINE_MAX];
  436.  
  437.         UBYTE    *Src = Buffer,
  438.             *Dst,
  439.              c;
  440.  
  441.         ULONG     Count;
  442.  
  443.         while(Size > 0)
  444.         {
  445.             Count = MIN(Size,BUFFER_LINE_MAX);
  446.  
  447.             Size -= Count;
  448.  
  449.             Dst = LocalBuffer;
  450.  
  451.             do
  452.             {
  453.                 if(c = ISOConversion[*Src++])
  454.                     *Dst++ = c;
  455.                 else
  456.                     *Dst++ = ' ';
  457.             }
  458.             while(--Count > 0);
  459.  
  460.             Count = (ULONG)Dst - (ULONG)&LocalBuffer[0];
  461.  
  462.             while(Count > 0 && LocalBuffer[Count - 1] == ' ')
  463.                 Count--;
  464.  
  465.             if(Count > 0)
  466.             {
  467.                 if(FWrite(PrinterCapture,LocalBuffer,Count,1) != 1)
  468.                 {
  469.                     BlockWindows();
  470.  
  471.                     if(!MyEasyRequest(Window,LocaleString(MSG_CONSOLE_ERROR_WRITING_TO_PRINTER_TXT),LocaleString(MSG_CONSOLE_IGNORE_CLOSE_PRINTER_TXT)))
  472.                     {
  473.                         Close(PrinterCapture);
  474.  
  475.                         CheckItem(MEN_CAPTURE_TO_PRINTER,FALSE);
  476.  
  477.                         PrinterCapture = NULL;
  478.  
  479.                         ConOutputUpdate();
  480.  
  481.                         Size = 0;
  482.                     }
  483.  
  484.                     ReleaseWindows();
  485.                 }
  486.             }
  487.         }
  488.     }
  489.     else
  490.     {
  491.         if(Size > 0)
  492.         {
  493.                 /* Send the buffer to the printer. */
  494.  
  495.             if(FWrite(PrinterCapture,Buffer,Size,1) != 1)
  496.             {
  497.                 BlockWindows();
  498.  
  499.                 if(!MyEasyRequest(Window,LocaleString(MSG_CONSOLE_ERROR_WRITING_TO_PRINTER_TXT),LocaleString(MSG_CONSOLE_IGNORE_CLOSE_PRINTER_TXT)))
  500.                 {
  501.                     Close(PrinterCapture);
  502.  
  503.                     CheckItem(MEN_CAPTURE_TO_PRINTER,FALSE);
  504.  
  505.                     PrinterCapture = NULL;
  506.  
  507.                     ConOutputUpdate();
  508.                 }
  509.  
  510.                 ReleaseWindows();
  511.             }
  512.         }
  513.     }
  514. }
  515.